home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / transprt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-16  |  12.4 KB  |  478 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4. */
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8.  
  9. #ifndef lint
  10. static char *RCSid = "$Header: /usr/users/freewais/FreeWAIS-0.1/ir/transprt.c,v 1.1 1993/02/16 15:05:35 freewais Exp $";
  11. #endif
  12.  
  13. /* this is a krufty transport layer for comm mediums that can not handle
  14.  * all 8 bits of ascii.
  15.  * Written by Harry Morris, modified by brewster.
  16.  * Hexcode written by Steve Swartz
  17.  * 
  18.  */
  19.  
  20. /* to do
  21.  *
  22.  *  compression
  23.  *  encryption
  24.  */
  25.  
  26. /* Change log:
  27.  * $Log: transprt.c,v $
  28.  * Revision 1.1  1993/02/16  15:05:35  freewais
  29.  * Initial revision
  30.  *
  31.  * Revision 1.2  92/02/12  13:51:34  jonathan
  32.  * Added "$Log" so RCS will put the log message in the header
  33.  * 
  34.  * 
  35.  * 7/7/90 -brewster
  36.  * merged arts and harry's changes 7/7/90 -brewster
  37.  *
  38.  * 11/6/90 -tracy
  39.  * shift 6 bytes starting from [ as IBM gateway program
  40.  * masks out characters [\]^` in input,
  41.  * append H and I to the function names corresponding to the
  42.  * oroginal coding and the modified one. 'I' indicates IBM. 
  43.  */
  44.  
  45. #include "transprt.h"
  46. #include "wmessage.h" 
  47. #include "ustubs.h"
  48.  
  49. /*---------------------------------------------------------------------*/
  50. static char alphaH[] = /* Must be 65 consecutive ascii characters */
  51.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnop";
  52.  
  53.  
  54. /*---------------------------------------------------------------------*/
  55.  
  56. static void hexCodeH _AP((char* data,long* len));
  57.  
  58. static void
  59. hexCodeH(data,len)
  60. char* data;
  61. long* len;
  62. /* compose a message for sending over ascii terminal lines. Input is '*len'
  63.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  64.  *
  65.  * Encoding goes like this. Let capital letters represent bits:
  66.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  67.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  68.  *
  69.  * 1 byte at end: ABCDEFGH
  70.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  71.  *
  72.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  73.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  74.  */
  75. {
  76.   long i, j;
  77.   
  78.   switch (*len % 3)
  79.     {
  80.     case 2:
  81.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  82.       data[j]   = alphaH[64];
  83.       data[j-1] = alphaH[data[i-1] & 0x0f];
  84.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  85.       data[j-3] = alphaH[data[i-2] & 0x3F];
  86.       break;
  87.     case 1:
  88.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  89.       data[j]   = alphaH[64];
  90.       data[j-1] = alphaH[64];
  91.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2];
  92.       data[j-3] = alphaH[data[i-2] & 0x3F];
  93.       break;
  94.     default:
  95.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  96.       break;
  97.     }
  98.   
  99.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  100.     { 
  101.       data[j]   = alphaH[data[i] & 0x3F];
  102.       data[j-1] = alphaH[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  103.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  104.       data[j-3] = alphaH[data[i-2] & 0x3F];
  105.     }
  106. }
  107.  
  108. /*---------------------------------------------------------------------*/
  109.  
  110. static void hexDecodeH _AP((char* data,long* len));
  111.  
  112. static void
  113. hexDecodeH(data,len)
  114. char* data;
  115. long* len;
  116. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  117.  *  will always be divisble by 4. Output is the binary bytes that were 
  118.  *  encoded into 'data'.
  119.  *
  120.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  121.  *  from ascii data to the 'bX' values has to become more complicated than
  122.  *  data[] - alpha[0].
  123.  */
  124. {
  125.   unsigned char b0, b1, b2, b3;
  126.   long i, j;
  127.  
  128.   
  129.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  130.     {
  131.       b0 = (data[j-4] & 0x07F) - alphaH[0];
  132.       b1 = (data[j-3] & 0x07F) - alphaH[0];
  133.       b2 = (data[j-2] & 0x07F) - alphaH[0];
  134.       b3 = (data[j-1] & 0x07F) - alphaH[0];
  135.       data[i-3] = b0 | (b1 & 0x30) << 2;
  136.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  137.       data[i-1] = b3 | (b2 & 0x30) << 2;
  138.     }
  139.  
  140.   *len = *len/4 * 3 - 2;
  141.   b0 = (data[j-4] & 0x07F) - alphaH[0];
  142.   b1 = (data[j-3] & 0x07F) - alphaH[0];
  143.   b2 = (data[j-2] & 0x07F) - alphaH[0];
  144.   b3 = (data[j-1] & 0x07F) - alphaH[0];
  145.   data[i-3] = b0 | (b1 & 0x30) << 2;
  146.  
  147.   if (b2 != 64)    
  148.     {
  149.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  150.       (*len)++;
  151.     }
  152.  
  153.   if (b3 != 64)
  154.     {
  155.       data[i-1] = b3 | (b2 & 0x30) << 2;
  156.       (*len)++;
  157.     }
  158. }
  159.  
  160. /*---------------------------------------------------------------------*/
  161.  
  162. void
  163. transportCodeH(data,len)
  164. char* data;
  165. long* len;
  166. /* krufty serial line transport layer - encode in hex and append in cr */
  167. /* Now it also writes a wais packet header on to the front of the packet.
  168.  *   --art 
  169.  */
  170. { 
  171.   hexCodeH(data,len);
  172.   data[*len] = '\r';
  173.   data[*len + 1] = '\0';
  174.   *len += 1;
  175. }
  176.  
  177. /*---------------------------------------------------------------------*/
  178.  
  179. void
  180. transportDecodeH(data,len)
  181. char* data;
  182. long* len;
  183. /* decode above */
  184. /* This does not have to deal with the wais packet header since it has
  185.    been removed at the end of the read.  */
  186. { 
  187.   if (*len == 0)
  188.     return;
  189.     
  190.   *len -= 1;
  191.   hexDecodeH(data,len);
  192. }
  193.  
  194. /*---------------------------------------------------------------------
  195.  Below are the set of transport coding/decoding functions for clients
  196.  dialing through IBM to DowQuest. Unlike the above one that
  197.  uses 65 consecutive ASCII character for the coding/decoding table,
  198.  table entries after charcater 'Z' are shift 6 characters.
  199.  *--------------------------------------------------------------------*/ 
  200.  
  201. #define LAST_NON_SHIFT_CHAR 90
  202. #define SHIFT_OFFSET   6
  203.  
  204. static char alphaI[] = 
  205.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv";
  206.  
  207.  
  208. static void hexCodeI _AP((char* data,long* len));
  209.  
  210. static void
  211. hexCodeI(data,len)
  212. char* data;
  213. long* len;
  214. /* compose a message for sending over ascii terminal lines. Input is '*len'
  215.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  216.  *
  217.  * Encoding goes like this. Let capital letters represent bits:
  218.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  219.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  220.  *
  221.  * 1 byte at end: ABCDEFGH
  222.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  223.  *
  224.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  225.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  226.  */
  227. {
  228.   long i, j;
  229.   
  230.   switch (*len % 3)
  231.     {
  232.     case 2:
  233.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  234.       data[j]   = alphaI[64];
  235.       data[j-1] = alphaI[data[i-1] & 0x0f];
  236.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  237.       data[j-3] = alphaI[data[i-2] & 0x3F];
  238.       break;
  239.     case 1:
  240.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  241.       data[j]   = alphaI[64];
  242.       data[j-1] = alphaI[64];
  243.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2];
  244.       data[j-3] = alphaI[data[i-2] & 0x3F];
  245.       break;
  246.     default:
  247.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  248.       break;
  249.     }
  250.   
  251.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  252.     { 
  253.       data[j]   = alphaI[data[i] & 0x3F];
  254.       data[j-1] = alphaI[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  255.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  256.       data[j-3] = alphaI[data[i-2] & 0x3F];
  257.     }
  258. }
  259.  
  260. /*---------------------------------------------------------------------*/
  261.  
  262. static void hexDecodeI _AP((char* data,long * len));
  263.  
  264. static void
  265. hexDecodeI(data,len)
  266. char* data;
  267. long* len;
  268. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  269.  *  will always be divisble by 4. Output is the binary bytes that were 
  270.  *  encoded into 'data'.
  271.  *
  272.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  273.  *  from ascii data to the 'bX' values has to become more complicated than
  274.  *  data[] - alpha[0].
  275.  */
  276. {
  277.   unsigned char b0, b1, b2, b3;
  278.   long i, j;
  279.  
  280.   for ( i=0; i < *len ; i++ )
  281.     if ( data[i] > LAST_NON_SHIFT_CHAR ) data[i] -= SHIFT_OFFSET;
  282.   
  283.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  284.     {
  285.       b0 = (data[j-4] & 0x07F) - alphaI[0];
  286.       b1 = (data[j-3] & 0x07F) - alphaI[0];
  287.       b2 = (data[j-2] & 0x07F) - alphaI[0];
  288.       b3 = (data[j-1] & 0x07F) - alphaI[0];
  289.       data[i-3] = b0 | (b1 & 0x30) << 2;
  290.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  291.       data[i-1] = b3 | (b2 & 0x30) << 2;
  292.     }
  293.  
  294.   *len = *len/4 * 3 - 2;
  295.   b0 = (data[j-4] & 0x07F) - alphaI[0];
  296.   b1 = (data[j-3] & 0x07F) - alphaI[0];
  297.   b2 = (data[j-2] & 0x07F) - alphaI[0];
  298.   b3 = (data[j-1] & 0x07F) - alphaI[0];
  299.   data[i-3] = b0 | (b1 & 0x30) << 2;
  300.  
  301.   if (b2 != 64)    
  302.     {
  303.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  304.       (*len)++;
  305.     }
  306.  
  307.   if (b3 != 64)
  308.     {
  309.       data[i-1] = b3 | (b2 & 0x30) << 2;
  310.       (*len)++;
  311.     }
  312. }
  313.  
  314. /*---------------------------------------------------------------------*/
  315.  
  316. void
  317. transportCodeI(data,len)
  318. char* data;
  319. long* len;
  320. /* krufty serial line transport layer - encode in hex and append in cr */
  321. /* Now it also writes a wais packet header on to the front of the packet.
  322.  *   --art 
  323.  */
  324. { 
  325.   hexCodeI(data,len);
  326.   data[*len] = '\r';
  327.   data[*len + 1] = '\0';
  328.   *len += 1;
  329. }
  330.  
  331. /*---------------------------------------------------------------------*/
  332.  
  333. void
  334. transportDecodeI(data,len)
  335. char* data;
  336. long* len;
  337. /* decode above */
  338. /* This does not have to deal with the wais packet header since it has
  339.    been removed at the end of the read.  */
  340. { 
  341.   if (*len == 0)
  342.     return;
  343.     
  344.   *len -= 1;
  345.   hexDecodeI(data,len);
  346. }
  347.  
  348. /*---------------------------------------------------------------------*/
  349.  
  350.  
  351. #ifdef NOTDEFINED /* here for back compatibility */
  352.  
  353. static void hexCode _AP((char* data,long * len));
  354.  
  355. static void
  356. hexCode(data,len)
  357. char* data;
  358. long* len;
  359. /* compose a message for sending over ascii terminal lines.  The data is hex,
  360.  */
  361. { long i;
  362.   for (i = *len-1; i >= 0; i--)
  363.     { data[i*2+1] = (data[i]&0x0F) + 'a';
  364.       data[i*2] = ((data[i]>>4)&0x0F) + 'a';
  365.     }
  366.   data[*len*2] = '\0';
  367.   *len = *len * 2;
  368. }
  369.  
  370. /*---------------------------------------------------------------------------*/
  371.  
  372. static void hexDecode _AP((char* data,long * len));
  373.  
  374. static void
  375. hexDecode(data,len)
  376. char* data;
  377. long* len;
  378. /* converts a buffer full of dataLen bytes of hex in place into the
  379. equivalent binary form. len is filled with the actual number of binary bytes.
  380.  */
  381. { long i;
  382.   *len = *len / 2;
  383.   for (i = 0; i < *len; i++)
  384.     { long temp = 0;
  385.       temp = (data[i*2]-'a')<<4;
  386.       temp += data[i*2+1]-'a';
  387.       data[i] = (char)temp;
  388.     }
  389.   data[*len] = '\0';
  390. }
  391.  
  392. #endif /* def NOTDEFINED */
  393. /*---------------------------------------------------------------------------*/
  394.  
  395. boolean
  396. transportCode(encoding,data,len)
  397. long encoding;
  398. char* data;
  399. long* len;
  400. /* krufty serial line transport layer - encode in hex and add trailing nl */
  401. {
  402.   switch (encoding){
  403.   case NO_ENCODING:
  404.     /* do nothing */
  405.     return(true);
  406.   case HEX_ENCODING:
  407.     transportCodeH(data,len);
  408.     return(true);
  409.   case IBM_HEXCODING:
  410.     transportCodeI(data,len);
  411.     return(true);
  412.   default:
  413.     return(false);
  414.   }
  415. }
  416.  
  417. /*---------------------------------------------------------------------------*/
  418.  
  419. boolean
  420. transportDecode(encoding,data,len)
  421. long encoding;
  422. char* data;
  423. long* len;
  424. /* decode above */
  425. {
  426.   switch (encoding){
  427.   case NO_ENCODING:
  428.     /* do nothing */
  429.     return(true);
  430.   case HEX_ENCODING:
  431.     transportDecodeH(data,len);
  432.     return(true);
  433.   case IBM_HEXCODING:
  434.     transportDecodeI(data,len);
  435.     return(true);
  436.   default:
  437.     return(false);
  438.   }
  439. }
  440.  
  441. /*---------------------------------------------------------------------------*/
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448. #ifdef old /* from the bad old days */
  449.  
  450.  
  451. /*---------------------------------------------------------------------------*/
  452.  
  453. void
  454. transportCode(data,len)
  455. char* data;
  456. long* len;
  457. /* krufty serial line transport layer - encode in hex and add trailing nl */
  458. {
  459.   hexCode(data,len);
  460.   data[*len] = '\r';
  461.   data[*len+1] = '\0';
  462. }
  463.  
  464. /*---------------------------------------------------------------------------*/
  465.  
  466. void
  467. transportDecode(data,len)
  468. char* data;
  469. long* len;
  470. /* decode above */
  471. {
  472.   hexDecode(data,len);
  473. }
  474.  
  475. /*---------------------------------------------------------------------------*/
  476.  
  477. #endif /* old */
  478.